
package Persistencia;

import Persistencia.exceptions.NonexistentEntityException;
import Persistencia.exceptions.PreexistingEntityException;
import java.util.List;
import motoressa.Administrativo;
import motoressa.Calle;
import motoressa.Cliente;
import motoressa.DetalleDePedido;
import motoressa.Egreso;
import motoressa.Empleado;
import motoressa.EncabezadoDePedido;
import motoressa.Especialidad;
import motoressa.Estado;
import motoressa.GrupoDeConstruccion;
import motoressa.InformeDeDiagnostico;
import motoressa.Ingreso;
import motoressa.Localidad;
import motoressa.Marca;
import motoressa.Modelo;
import motoressa.Operacion;
import motoressa.OrdenDeReparacion;
import motoressa.Persona;
import motoressa.Proveedor;
import motoressa.Repuesto;
import motoressa.Segmento;
import motoressa.Servicio;
import motoressa.Stock;
import motoressa.Sucursal;
import motoressa.Taller;
import motoressa.Tecnico;
import motoressa.TipoDeServicio;
import motoressa.TipoPedido;
import motoressa.Turno;
import motoressa.Vehiculo;
import motoressa.Zona;

/**
 *ESTA CLASE SIRVE PARA QUE PODAMOS INTERECTUAR CON LAS DIFERENTES JPA CONTROLLER
 * LAS JPA CONTROLLER SON EL NEXO ENTRE EL SISTEMA Y LA BASE DE DATOS
 * 
 */

public class ControladoraPersistencia {
    
    //DECLARACION DE UNA VARIABLE DEL TIPO DE LA CONTROLADORA JPA, POR CADA UNA DE LAS QUE HEMOS DEFINIDO
    AdministrativoJpaController miAdministrativoJpa=new AdministrativoJpaController();
    CalleJpaController miCalleJpa=new CalleJpaController();
    ClienteJpaController miClienteJpa=new ClienteJpaController ();
    DetalleDePedidoJpaController miDetalleDePedidoJpa=new DetalleDePedidoJpaController ();
    EgresoJpaController miEgresoJpa=new EgresoJpaController ();
    EmpleadoJpaController miEmpleadoJpa=new EmpleadoJpaController ();
    EncabezadoDePedidoJpaController miEncabezadoDePedidoJpa=new EncabezadoDePedidoJpaController ();
    EspecialidadJpaController miEspecialidadJpa=new EspecialidadJpaController ();
    EstadoJpaController miEstadoJpa=new EstadoJpaController ();
    GrupoDeConstruccionJpaController miGrupoDeConstruccionJpa=new GrupoDeConstruccionJpaController ();
    InformeDeDiagnosticoJpaController miInformeDeDiagnosticoJpa=new InformeDeDiagnosticoJpaController ();
    IngresoJpaController miIngresoJpa=new IngresoJpaController();
    LocalidadJpaController miLocalidadJpa=new LocalidadJpaController();
    MarcaJpaController miMarcaJpa=new MarcaJpaController();
    ModeloJpaController miModeloJpa=new ModeloJpaController();
    OperacionJpaController miOperacionJpa=new OperacionJpaController();
    OrdenDeReparacionJpaController miOrdenDeReparacionJpa=new OrdenDeReparacionJpaController();
    PersonaJpaController miPersonaJpa=new PersonaJpaController();
    ProveedorJpaController miProveedorJpa=new ProveedorJpaController();
    RepuestoJpaController miRepuestoJpa=new RepuestoJpaController();
    SegmentoJpaController miSegmentoJpa=new SegmentoJpaController();
    ServicioJpaController miServicioJpa=new ServicioJpaController();
    StockJpaController miStockJpa=new StockJpaController();
    SucursalJpaController miSucursalJpa=new SucursalJpaController();
    TallerJpaController miTallerJpa=new TallerJpaController();
    TecnicoJpaController miTecnicoJpa=new TecnicoJpaController();
    TipoDeServicioJpaController miTipoDeServicioJpa=new TipoDeServicioJpaController();
    TipoPedidoJpaController miTipoPedidoJpa=new TipoPedidoJpaController();
    TurnoJpaController miTurnoJpa=new TurnoJpaController();
    VehiculoJpaController miVehiculoJpa=new VehiculoJpaController();
    ZonaJpaController miZonaJpa=new ZonaJpaController();
    
    
    //CLASE CALLE
    // METODO PARA AGREGAR UNA NUEVA INSTANCIA DEL OBJETO CALLE EN LA BASE DE DATOS
    public void agregarCalle(Calle unaCalle) throws PreexistingEntityException, Exception{
        miCalleJpa.create(unaCalle);
    }
    //METODO PARA EDITAR UNA INSTANCIA YA CREADA EN LA BASE DE DATOS
    public void editarCalle(Calle unaCalle) throws NonexistentEntityException, Exception{
        miCalleJpa.edit(unaCalle);
    }
    //METODO PARA ELIMINAR UNA INSTANCIA DE LA BASE DE DATOS, TRABAJA A NIVEL DEL IDENTIFICADOR DE LA CLASE
    public void eliminarCalle(int ID) throws NonexistentEntityException{
        miCalleJpa.destroy(ID);
    }
    //METODO PARA OBTENTER UNA INSTANCIA DETERMINADA DESDE LA BASE DE DATOS, TRABAJA A NIVEL DEL IDENTIFICADOR DE LA CLASE
    public Calle dameMiCalle(int ID){
        return miCalleJpa.findCalle(ID);
    }
    //METODO PARA DEVOLVER TODAS LAS INSTANCIAS DE LA CLASE DESDE LA BASE DE DATOS
    public List<Calle> dameMisCalles(){
        return miCalleJpa.findCalleEntities();
    }
    
    public void agregarAdministrativo(Administrativo unAdministrativo) throws PreexistingEntityException, Exception{
        miAdministrativoJpa.create(unAdministrativo);
    }  
    public void editarAdministrativo(Administrativo unAdministrativo) throws NonexistentEntityException, Exception{
        miAdministrativoJpa.edit(unAdministrativo);
    }   
    public void eliminarAdministrativo(String ID) throws NonexistentEntityException{
        miAdministrativoJpa.destroy(ID);
    }    
    public Administrativo dameMiAdministrativo(String ID){
        return miAdministrativoJpa.findAdministrativo(ID);
    }
    public List<Administrativo> dameMisAdministrativos(){
        return miAdministrativoJpa.findAdministrativoEntities();
    }
    
    
    public void agregarCliente(Cliente unCliente) throws PreexistingEntityException, Exception{
        miClienteJpa.create(unCliente);
    }
    public void editarCliente(Cliente unCliente) throws NonexistentEntityException, Exception{
        miClienteJpa.edit(unCliente);
    }
    public void eliminarCliente(String ID) throws NonexistentEntityException{
        miClienteJpa.destroy(ID);
    }
    public Cliente dameMiCliente(String ID){
        return miClienteJpa.findCliente(ID);
    }
    public List<Cliente> dameMisClientes(){
        return miClienteJpa.findClienteEntities();
    }
    
   public void agregarDetalleDePedido(DetalleDePedido unDetalleDePedido) throws PreexistingEntityException, Exception{
        miDetalleDePedidoJpa.create(unDetalleDePedido);
    }
    //METODO PARA EDITAR UNA INSTANCIA YA CREADA EN LA BASE DE DATOS
    public void editarDetalleDePedido(DetalleDePedido unDetalleDePedido) throws NonexistentEntityException, Exception{
        miDetalleDePedidoJpa.edit(unDetalleDePedido);
    }
    //METODO PARA ELIMINAR UNA INSTANCIA DE LA BASE DE DATOS, TRABAJA A NIVEL DEL IDENTIFICADOR DE LA CLASE
    public void eliminarDetalleDePedido(int ID) throws NonexistentEntityException{
        miDetalleDePedidoJpa.destroy(ID);
    }
    //METODO PARA OBTENTER UNA INSTANCIA DETERMINADA DESDE LA BASE DE DATOS, TRABAJA A NIVEL DEL IDENTIFICADOR DE LA CLASE
    public DetalleDePedido dameMiDetalleDePedido(int ID){
        return miDetalleDePedidoJpa.findDetalleDePedido(ID);
    }
    //METODO PARA DEVOLVER TODAS LAS INSTANCIAS DE LA CLASE DESDE LA BASE DE DATOS
    public List<DetalleDePedido> dameMisDetallesDePedido(){
        return miDetalleDePedidoJpa.findDetalleDePedidoEntities(); 
    }
    
     public void agregarEgreso(Egreso unEgreso) throws PreexistingEntityException, Exception{
        miEgresoJpa.create(unEgreso);
    }  
    public void editarEgreso(Egreso unEgreso) throws NonexistentEntityException, Exception{
        miEgresoJpa.edit(unEgreso);
    }   
    public void eliminarEgreso(int ID) throws NonexistentEntityException{
        miEgresoJpa.destroy(ID);
    }    
    public Egreso dameMiEgreso(int ID){
        return miEgresoJpa.findEgreso(ID);
    }
    public List<Egreso> dameMisEgresos(){
        return miEgresoJpa.findEgresoEntities();
    }
    
    public void agregarEmpleado(Empleado unEmpleado) throws PreexistingEntityException, Exception{
        miEmpleadoJpa.create(unEmpleado);
    }  
    public void editarEmpleado(Empleado unEmpleado) throws NonexistentEntityException, Exception{
        miEmpleadoJpa.edit(unEmpleado);
    }   
    public void eliminarEmpleado(String ID) throws NonexistentEntityException{
        miEmpleadoJpa.destroy(ID);
    }    
    public Empleado dameMiEmpleado(String ID){
        return miEmpleadoJpa.findEmpleado(ID);
    }
    public List<Empleado> dameMisEmpleados(){
        return miEmpleadoJpa.findEmpleadoEntities(); 
    }
    
    public void agregarEncabezadoDePedido(EncabezadoDePedido unEncabezadoDePedido) throws PreexistingEntityException, Exception{
        miEncabezadoDePedidoJpa.create(unEncabezadoDePedido);
    }  
    public void editarEncabezadoDePedido(EncabezadoDePedido unEncabezadoDePedido) throws NonexistentEntityException, Exception{
        miEncabezadoDePedidoJpa.edit(unEncabezadoDePedido);
    }   
    public void eliminarEncabezadoDePedido(int ID) throws NonexistentEntityException{
        miEncabezadoDePedidoJpa.destroy(ID);
    }    
    public EncabezadoDePedido dameMiEncabezadoDePedido(int ID){
        return miEncabezadoDePedidoJpa.findEncabezadoDePedido(ID);
    }
    public List<EncabezadoDePedido> dameMisEncabezadosDePedidos(){
        return miEncabezadoDePedidoJpa.findEncabezadoDePedidoEntities(); 
    }
    
    public void agregarEspecialidad(Especialidad unaEspecialidad) throws PreexistingEntityException, Exception{
        miEspecialidadJpa.create(unaEspecialidad);
    }  
    public void editarEspecialidad(Especialidad unaEspecialidad) throws NonexistentEntityException, Exception{
        miEspecialidadJpa.edit(unaEspecialidad);
    }   
    public void eliminarEspecialidad(int ID) throws NonexistentEntityException{
        miEspecialidadJpa.destroy(ID);
    }    
    public Especialidad dameMiE(int ID){
        return miEspecialidadJpa.findEspecialidad(ID);
    }
    public List<Especialidad> dameMisEspecialidad(){
        return miEspecialidadJpa.findEspecialidadEntities(); 
    }
    
    public void agregarEstado(Estado unEstado) throws PreexistingEntityException, Exception{
        miEstadoJpa.create(unEstado);
    }  
    public void editarEstado(Estado unEstado) throws NonexistentEntityException, Exception{
        miEstadoJpa.edit(unEstado);
    }   
    public void eliminarE(int ID) throws NonexistentEntityException{
        miEstadoJpa.destroy(ID);
    }    
    public Estado dameMiEstado(int ID){
        return miEstadoJpa.findEstado(ID);
    }
    public List<Estado> dameMisEstado(){
        return miEstadoJpa.findEstadoEntities(); 
    }
    
    
    public void agregarGrupoDeConstruccion(GrupoDeConstruccion unGrupoDeConstruccion) throws PreexistingEntityException, Exception{
        miGrupoDeConstruccionJpa.create(unGrupoDeConstruccion);
    }  
    public void editarGrupoDeConstruccion(GrupoDeConstruccion unGrupoDeConstruccion) throws NonexistentEntityException, Exception{
        miGrupoDeConstruccionJpa.edit(unGrupoDeConstruccion);
    }   
    public void eliminarGrupoDeConstruccion(int ID) throws NonexistentEntityException{
        miGrupoDeConstruccionJpa.destroy(ID);
    }    
    public GrupoDeConstruccion dameMiGrupoDeConstruccion(int ID){
        return miGrupoDeConstruccionJpa.findGrupoDeConstruccion(ID);
    }
    public List<GrupoDeConstruccion> dameMisGruposDeConstruccion(){
        return miGrupoDeConstruccionJpa.findGrupoDeConstruccionEntities();
    }
    
    
    public void agregarInformeDeDiagnostico(InformeDeDiagnostico unInformeDeDiagnostico) throws PreexistingEntityException, Exception{
        miInformeDeDiagnosticoJpa.create(unInformeDeDiagnostico);
    }  
    public void editarInformeDeDiagnostico(InformeDeDiagnostico unInformeDeDiagnostico) throws NonexistentEntityException, Exception{
        miInformeDeDiagnosticoJpa.edit(unInformeDeDiagnostico);
    }   
    public void eliminarInformeDeDiagnostico(int ID) throws NonexistentEntityException{
        miInformeDeDiagnosticoJpa.destroy(ID);
    }    
    public InformeDeDiagnostico dameMiInformeDeDiagnostico(int ID){
        return miInformeDeDiagnosticoJpa.findInformeDeDiagnostico(ID);
    }
    public List<InformeDeDiagnostico> dameMisInformeDeDiagnostico(){
        return miInformeDeDiagnosticoJpa.findInformeDeDiagnosticoEntities();
    }
    
    public void agregarIngreso(Ingreso unIngreso) throws PreexistingEntityException, Exception{
        miIngresoJpa.create(unIngreso);
    }  
    public void editarIngreso(Ingreso unIngreso) throws NonexistentEntityException, Exception{
        miIngresoJpa.edit(unIngreso);
    }   
    public void eliminarIngreso(int ID) throws NonexistentEntityException{
        miIngresoJpa.destroy(ID);
    }    
    public Ingreso dameMiIngreso(int ID){
        return miIngresoJpa.findIngreso(ID);
    }
    public List<Ingreso> dameMisIngresos(){
        return miIngresoJpa.findIngresoEntities();
    }
    
   
    public void agregarLocalidad(Localidad unaLocalidad) throws PreexistingEntityException, Exception{
        miLocalidadJpa.create(unaLocalidad);
    }  
    public void editarLocalidad(Localidad unaLocalidad) throws NonexistentEntityException, Exception{
        miLocalidadJpa.edit(unaLocalidad);
    }   
    public void eliminarLocalidad(int ID) throws NonexistentEntityException{
        miLocalidadJpa.destroy(ID);
    }    
    public Localidad dameMiLocalidad(int ID){
        return miLocalidadJpa.findLocalidad(ID);
    }
    public List<Localidad> dameMisLocalidades(){
        return miLocalidadJpa.findLocalidadEntities();
    }
    
     public void agregarMarca(Marca unaMarca) throws PreexistingEntityException, Exception{
        miMarcaJpa.create(unaMarca);
    }  
    public void editarMarca(Marca unaMarca) throws NonexistentEntityException, Exception{
        miMarcaJpa.edit(unaMarca);
    }   
    public void eliminarMarca(int ID) throws NonexistentEntityException{
        miMarcaJpa.destroy(ID);
    }    
    public Marca dameMiMarca(int ID){
        return miMarcaJpa.findMarca(ID);
    }
    public List<Marca> dameMisMarcas(){
        return miMarcaJpa.findMarcaEntities();
    }
    
     public void agregarModelo(Modelo unModelo) throws PreexistingEntityException, Exception{
        miModeloJpa.create(unModelo);
    }  
    public void editarModelo(Modelo unModelo) throws NonexistentEntityException, Exception{
        miModeloJpa.edit(unModelo);
    }   
    public void eliminarModelo(int ID) throws NonexistentEntityException{
        miModeloJpa.destroy(ID);
    }    
    public Modelo dameMiModelo(int ID){
        return miModeloJpa.findModelo(ID);
    }
    public List<Modelo> dameMisMOdelos(){
        return miModeloJpa.findModeloEntities();
    }
    
    public void agregarOperacion(Operacion unaOperacion) throws PreexistingEntityException, Exception{
        miOperacionJpa.create(unaOperacion);
    }  
    public void editarOperacion(Operacion unaOperacion) throws NonexistentEntityException, Exception{
        miOperacionJpa.edit(unaOperacion);
    }   
    public void eliminarOperacion(int ID) throws NonexistentEntityException{
        miOperacionJpa.destroy(ID);
    }    
    public Operacion dameMiOperacion(int ID){
        return miOperacionJpa.findOperacion(ID);
    }
    public List<Operacion> dameMisOperaciones(){
        return miOperacionJpa.findOperacionEntities();
    }
    
    public void agregarOrdenDeReparacion(OrdenDeReparacion unaOrdenDeReparacion) throws PreexistingEntityException, Exception{
        miOrdenDeReparacionJpa.create(unaOrdenDeReparacion);
    }  
    public void editarOrdenDeReparacion(OrdenDeReparacion unaOrdenDeReparacion) throws NonexistentEntityException, Exception{
        miOrdenDeReparacionJpa.edit(unaOrdenDeReparacion);
    }   
    public void eliminarOrdenDeReparacion(int ID) throws NonexistentEntityException{
        miOrdenDeReparacionJpa.destroy(ID);
    }    
    public OrdenDeReparacion dameMiOrdenDeReparacion(int ID){
        return miOrdenDeReparacionJpa.findOrdenDeReparacion(ID);
    }
    public List<OrdenDeReparacion> dameMisOrdenesDeReparaciones(){
        return miOrdenDeReparacionJpa.findOrdenDeReparacionEntities();
    }
    
    public void agregarPersona(Persona unaPersona) throws PreexistingEntityException, Exception{
        miPersonaJpa.create(unaPersona);
    }  
    public void editar(Persona unaPersona) throws NonexistentEntityException, Exception{
        miPersonaJpa.edit(unaPersona);
    }   
    public void eliminarPersona(String ID) throws NonexistentEntityException{
        miPersonaJpa.destroy(ID);
    }    
    public Persona dameMiPersona(String ID){
        return miPersonaJpa.findPersona(ID);
    }
    public List<Persona> dameMisPersonas(){
        return miPersonaJpa.findPersonaEntities();
    }
    
    public void agregarProveedor(Proveedor unProveedor) throws PreexistingEntityException, Exception{
        miProveedorJpa.create(unProveedor);
    }  
    public void editar(Proveedor unProveedor) throws NonexistentEntityException, Exception{
        miProveedorJpa.edit(unProveedor);
    }   
    public void eliminarProveedor(String ID) throws NonexistentEntityException{
        miProveedorJpa.destroy(ID);
    }    
    public Proveedor dameMiProveedor(String ID){
        return miProveedorJpa.findProveedor(ID);
    }
    public List<Proveedor> dameMisProveedores(){
        return miProveedorJpa.findProveedorEntities();
    }
    
    public void agregarRepuesto(Repuesto unRepuesto) throws PreexistingEntityException, Exception{
        miRepuestoJpa.create(unRepuesto);
    }  
    public void editar(Repuesto unRepuesto) throws NonexistentEntityException, Exception{
        miRepuestoJpa.edit(unRepuesto);
    }   
    public void eliminarRepuesto(int ID) throws NonexistentEntityException{
        miRepuestoJpa.destroy(ID);
    }    
    public Repuesto dameMiRepuesto(int ID){
        return miRepuestoJpa.findRepuesto(ID);
    }
    public List<Repuesto> dameMisRepuestos(){
        return miRepuestoJpa.findRepuestoEntities();
    }
    
    public void agregarSegmento(Segmento unSegmento) throws PreexistingEntityException, Exception{
        miSegmentoJpa.create(unSegmento);
    }  
    public void editar(Segmento unSegmento) throws NonexistentEntityException, Exception{
        miSegmentoJpa.edit(unSegmento);
    }   
    public void eliminarSegmento(int ID) throws NonexistentEntityException{
        miSegmentoJpa.destroy(ID);
    }    
    public Segmento dameMiSegmento(int ID){
        return miSegmentoJpa.findSegmento(ID);
    }
    public List<Segmento> dameMisSegmentos(){
        return miSegmentoJpa.findSegmentoEntities();
    }
    
    public void agregarServicio(Servicio unServicio) throws PreexistingEntityException, Exception{
        miServicioJpa.create(unServicio);
    }  
    public void editar(Servicio unServicio) throws NonexistentEntityException, Exception{
        miServicioJpa.edit(unServicio);
    }   
    public void eliminarServicio(int ID) throws NonexistentEntityException{
        miServicioJpa.destroy(ID);
    }    
    public Servicio dameMiServicios(int ID){
        return miServicioJpa.findServicio(ID);
    }
    public List<Servicio> dameMisServicios(){
        return miServicioJpa.findServicioEntities();
    }
    
    public void agregarStock(Stock unStock) throws PreexistingEntityException, Exception{
        miStockJpa.create(unStock);
    }  
    public void editar(Stock unStock) throws NonexistentEntityException, Exception{
        miStockJpa.edit(unStock);
    }   
    public void eliminarStock(int ID) throws NonexistentEntityException{
        miStockJpa.destroy(ID);
    }    
    public Stock dameMistocks(int ID){
        return miStockJpa.findStock(ID);
    }
    public List<Stock> dameMisStock(){
        return miStockJpa.findStockEntities();
    }
    
    public void agregarSucursal(Sucursal unaSucursal) throws PreexistingEntityException, Exception{
        miSucursalJpa.create(unaSucursal);
    }  
    public void editar(Sucursal unaSucursal) throws NonexistentEntityException, Exception{
        miSucursalJpa.edit(unaSucursal);
    }   
    public void eliminarSucursal(int ID) throws NonexistentEntityException{
        miSucursalJpa.destroy(ID);
    }    
    public Sucursal dameMisSucursales(int ID){
        return miSucursalJpa.findSucursal(ID);
    }
    public List<Sucursal> dameMisSucursales(){
        return miSucursalJpa.findSucursalEntities();
    }
    
    
     public void agregarTaller(Taller unTaller) throws PreexistingEntityException, Exception{
        miTallerJpa.create(unTaller);
    }  
    public void editar(Taller unTaller) throws NonexistentEntityException, Exception{
        miTallerJpa.edit(unTaller);
    }   
    public void eliminarTaller(int ID) throws NonexistentEntityException{
        miTallerJpa.destroy(ID);
    }    
    public Taller dameMisTalleres(int ID){
        return miTallerJpa.findTaller(ID);
    }
    public List<Taller> dameMisTalleres(){
        return miTallerJpa.findTallerEntities();
    }
      
    public void agregarTecnico(Tecnico unTecnico) throws PreexistingEntityException, Exception{
        miTecnicoJpa.create(unTecnico);
    }  
    public void editar(Tecnico unTecnico) throws NonexistentEntityException, Exception{
        miTecnicoJpa.edit(unTecnico);
    }   
    public void eliminarTecnico(String ID) throws NonexistentEntityException{
        miTecnicoJpa.destroy(ID);
    }    
    public Tecnico dameMisTecnicos(String ID){
        return miTecnicoJpa.findTecnico(ID);
    }
    public List<Tecnico> dameMisTecnicos(){
        return miTecnicoJpa.findTecnicoEntities();
    }   
    
     public void agregarTipoDeServicio(TipoDeServicio unTipoDeServicio) throws PreexistingEntityException, Exception{
        miTipoDeServicioJpa.create(unTipoDeServicio);
    }  
    public void editar(TipoDeServicio unTipoDeServicio) throws NonexistentEntityException, Exception{
        miTipoDeServicioJpa.edit(unTipoDeServicio);
    }   
    public void eliminarTipoDeServicio(int ID) throws NonexistentEntityException{
        miTipoDeServicioJpa.destroy(ID);
    }    
    public TipoDeServicio dameMisTiposDeServicios(int ID){
        return miTipoDeServicioJpa.findTipoDeServicio(ID);
    }
    public List<TipoDeServicio> dameMisTiposDeServicios(){
        return miTipoDeServicioJpa.findTipoDeServicioEntities();
    }   
    
    public void agregarTipoPedido(TipoPedido unTipoPedido) throws PreexistingEntityException, Exception{
        miTipoPedidoJpa.create(unTipoPedido);
    }  
    public void editar(TipoPedido unTipoPedido) throws NonexistentEntityException, Exception{
        miTipoPedidoJpa.edit(unTipoPedido);
    }   
    public void eliminarTipoPedido(int ID) throws NonexistentEntityException{
        miTipoPedidoJpa.destroy(ID);
    }    
    public TipoPedido dameMisTiposPedidos(int ID){
        return miTipoPedidoJpa.findTipoPedido(ID);
    }
    public List<TipoPedido> dameMisTiposPedidos(){
        return miTipoPedidoJpa.findTipoPedidoEntities();
    }
    
    
    public void agregarTurno(Turno unTurno) throws PreexistingEntityException, Exception{
        miTurnoJpa.create(unTurno);
    }  
    public void editar(Turno unTurno) throws NonexistentEntityException, Exception{
        miTurnoJpa.edit(unTurno);
    }   
    public void eliminarTurno(int ID) throws NonexistentEntityException{
        miTurnoJpa.destroy(ID);
    }    
    public Turno dameMisTurnos(int ID){
        return miTurnoJpa.findTurno(ID);
    }
    public List<Turno> dameMisTurnos(){
        return miTurnoJpa.findTurnoEntities();
    }
    
    public void agregarVehiculo(Vehiculo unVehiculo) throws PreexistingEntityException, Exception{
        miVehiculoJpa.create(unVehiculo);
    }  
    public void editar(Vehiculo unVehiculo) throws NonexistentEntityException, Exception{
        miVehiculoJpa.edit(unVehiculo);
    }   
    public void eliminarVehiculo(String ID) throws NonexistentEntityException{
        miVehiculoJpa.destroy(ID);
    }    
    public Vehiculo dameMisVehiculos(String ID){
        return miVehiculoJpa.findVehiculo(ID);
    }
    public List<Vehiculo> dameMisVehiculos(){
        return miVehiculoJpa.findVehiculoEntities();
    }
    
    public void agregarZona(Zona unZona) throws PreexistingEntityException, Exception{
        miZonaJpa.create(unZona);
    }  
    public void editar(Zona unaZona) throws NonexistentEntityException, Exception{
        miZonaJpa.edit(unaZona);
    }   
    public void eliminarZona(int ID) throws NonexistentEntityException{
        miZonaJpa.destroy(ID);
    }    
    public Zona dameMisZonas(int ID){
        return miZonaJpa.findZona(ID);
    }
    public List<Zona> dameMisZonas(){
        return miZonaJpa.findZonaEntities();
    }
}   


